class StringHandle{
    constructor(){

    }
    /**
     * 判断是否已某字符串开头
     * @param {*} str 
     * @param {*} startStr 
     */
    startWith(str,startStr){
        if(!startStr || !str){return false;}
        return new RegExp("^"+str).test(str);
    }

    isType(type){
        type = type.charAt(0).toUpperCase()+type.substring(1);
        return (obj)=>{
            return Object.prototype.toString.call(obj) == "[object "+type+"]";
        }
    }

    /**
     * 判断是否已某字符串结尾
     * @param {*} str 
     * @param {*} endStr 
     */
    endWidth(str,endStr){
        if(!endStr || !str){return false;}
        return new RegExp(str+"$").test(this);
    }
    /**
     * 首字母转为大写
     * @param {*} str 
     */
    firstWordToUpCase(str){
        return str.toLowerCase().replace(/\b(\w)|\s(\w)/g,function(word){return word.toUpperCase()})
    }
    /**
     * 首字母大写
     */
    firstLetter(str){
        return str.chartAt(0).toUpperCase()+str.substring(1);
    }
    /**
     * kebab-case转camelCase
     * @param {*} str 
     */
    toCamelCase(str){
        return str.replace(/-\w/g,function(x) {
            return x.slice(1).toUpperCase();
        });
    }
    /**
     * camelCase转kebab-case
     */
    toKebabCase(){
        return str.replace(/[A-Z]/g,function(x) {
            return '-'+x.toLowerCase();
        });
    }
    /**
     * 句子反转
     * @param {*} str 
     */
    sentenceReverse(str){
        return str.trim().replace(/\s+/g,' ').split(' ').reverse().join(' ')
    }
    /**
     * 字母翻转
     */
    letterReverse(str){
        return str.split('').join('')
    }
    /**
     * 拼接queryStr
     * @param {*} obj 
     */
    joinQueryStr(obj){
        let args = "?";
        Object.keys(obj).forEach(function(key){
            let val = obj[key]||''
            args += key+"="+encodeURIComponent(val)+"&";
        });
        return args.substring(0,args.length-1);
    }
    /**
     * 获取查询字符
     * @param {*} pattern 
     */
    getQueryStr(pattern){
        let argStr = pattern=='hash' ? location.hash.substring(1) : /.+\?(.+)$/.exec(location.href)[1]
        ,argArr = argStr.split('&')
        ,params = {};
        argArr.forEach(param => {
            if (/=/.test(param)) { // 处理有 value 的参数
                let [key, val] = param.split('='); // 分割 key 和 value
                val = decodeURIComponent(val); // 解码 //加密：encodeURIComponent()
                val = /^\d+$/.test(val) ? parseFloat(val) : val; // 判断是否转为数字
                if (params.hasOwnProperty(key)) {
                    params[key] = [].concat(params[key], val);
                } else {
                    params[key] = val;
                }
            }
        });
        return params;
    }
    /**
     * @description 格式化时间
     * @param {String|Number} dateTime 需要格式化的时间戳
     * @param {String} fmt 格式化规则 yyyy:mm:dd|yyyy:mm|yyyy年mm月dd日|yyyy年mm月dd日 hh时MM分等,可自定义组合 默认yyyy-mm-dd
     * @returns {string} 返回格式化后的字符串
     */
    timeFormat(dateTime = null, formatStr = 'yyyy-mm-dd') {
        let date
        // 若传入时间为假值，则取当前时间
        if (!dateTime) {
            date = new Date()
        }
        // 若为unix秒时间戳，则转为毫秒时间戳（逻辑有点奇怪，但不敢改，以保证历史兼容）
        else if (/^\d{10}$/.test(dateTime?.toString().trim())) {
            date = new Date(dateTime * 1000)
        }
        // 若用户传入字符串格式时间戳，new Date无法解析，需做兼容
        else if (typeof dateTime === 'string' && /^\d+$/.test(dateTime.trim())) {
            date = new Date(Number(dateTime))
        }
        // 其他都认为符合 RFC 2822 规范
        else {
            // 处理平台性差异，在Safari/Webkit中，new Date仅支持/作为分割符的字符串时间
            date = new Date(
                typeof dateTime === 'string'
                ? dateTime.replace(/-/g, '/')
                : dateTime
            )
        }
        const timeSource = {
            'y': date.getFullYear().toString(), // 年
            'm': (date.getMonth() + 1).toString().padStart(2, '0'), // 月
            'd': date.getDate().toString().padStart(2, '0'), // 日
            'h': date.getHours().toString().padStart(2, '0'), // 时
            'M': date.getMinutes().toString().padStart(2, '0'), // 分
            's': date.getSeconds().toString().padStart(2, '0') // 秒
            // 有其他格式化字符需求可以继续添加，必须转化成字符串
        }
        for (const key in timeSource) {
            const [ret] = new RegExp(`${key}+`).exec(formatStr) || []
            if (ret) {
                // 年可能只需展示两位
                const beginIndex = key === 'y' && ret.length === 2 ? 2 : 0
                formatStr = formatStr.replace(ret, timeSource[key].slice(beginIndex))
            }
        }
        return formatStr
    }

    /**
     * 16进制颜色转RGB
     * @param {*} hex -->'#ffffff'
     */
    hexToRGB(hex){
        let hex = hex.replace("#","0x"),
        r = hex >> 16,
        g = hex >> 8 & 0xff,
        b = hex & 0xff;
        return "rgb("+r+","+g+","+b+")";
    }
    /**
     * RGB转16进制颜色
     * @param {*} rgb 
     * RGBToHex("rgb(255,255,255)")返回"#ffffff"
     */
    RGBToHex(rgb){
        let rgbArr = rgb.split(/[^\d]+/),
        color = rgbArr[1]<<16 | rgbArr[2]<<8 | rgbArr[3];
        return "#"+color.toString(16);
    }
    //转base64
    toBase64(file,callback){
        let fileReader = new FileReader()
        fileReader.readAsDataURL(file);
        fileReader.addEventListener('load',function(){
            typeof callback == 'function' && callback.call(this,this.result)
        })
    }
    // 千分位分隔符
    parseToMoney(str) {
        str = utils.isExist(str, true) ? str : '0';
        return str.toString().replace(/(?<!\..*)(?<=\d)(?=(\d{3})+(\.|$))/g, ",")
    }
    // 格式化金额
    formatDinero(num) {
       return num.toLocaleString('zh-CN', {style:'currency', currency: 'CNY'});
    }
    // 小数点保留多少位
    deci(value, deciNum = 2) {
        const baseNum = Math.pow(10, deciNum);
        return (Math.round(value * baseNum) / baseNum).toFixed(deciNum);
    }
    //解析文件路径。类似于path.resolve
    resolve(...paths){
        let resolvePath = '';
        let isAbsolutePath = false;
        for(let i = paths.length-1; i > -1; i--){
            let path = paths[i];
            if(isAbsolutePath){
                break;
            }
            if(!path){
                continue
            }
            resolvePath = path + '/' + resolvePath;
            isAbsolutePath = path.charCodeAt(0) === 47;
        }
        if(/^\/+$/.test(resolvePath)){
            resolvePath = resolvePath.replace(/(\/+)/,'/')
        }else{
            resolvePath = resolvePath.replace(/(?!^)\w+\/+\.{2}\//g, '')
            .replace(/(?!^)\.\//g,'')
            .replace(/\/+$/, '')
        }
        return resolvePath;
    }

    //中文转unicode
    unicode(str){
        var value='';
        for (var i = 0; i < str.length; i++) {
            value += '\\u' + this.left_zero_4(parseInt(str.charCodeAt(i)).toString(16));
        }
        return value;
    }
    left_zero_4(str) {
        if (str != null && str != '' && str != 'undefined') {
            if (str.length == 2) {
                return '00' + str;
            }
        }
        return str;
    }
    // 重量单位转换 weightRef(2, 'mg', 'g') | weightRef(2, 0, 1)
    weightRef(value, ...units){
        const weightUnit = ['mg', 'g', 'kg', 't'];
        units = units.map((unit) => {
            if(!/^\d$/.test(unit)){
                unit = weightUnit.indexOf(unit.toLocaleLowerCase());
            }
            return unit;
        });
        const isltZero = units.some((unit) => unit < 0);
        if(isltZero < 0){
            return new Error("参数有误")
        }
        const pow = Math.pow(10,  (units[0] - units[1])* 3);
        return value * pow;
    }
}